home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1995 January / macformat-020.iso / Shareware City / Developers / OutOfPhase1.01Source / OutOfPhase Folder / Level 0 Macintosh 07Aug94 / FloatingPoint.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-01  |  3.4 KB  |  186 lines  |  [TEXT/KAHL]
  1. /* FloatingPoint.c */
  2. /*****************************************************************************/
  3. /*                                                                           */
  4. /*    System Dependency Library for Building Portable Software               */
  5. /*    Macintosh Version                                                      */
  6. /*    Written by Thomas R. Lawrence, 1993 - 1994.                            */
  7. /*                                                                           */
  8. /*    This file is Public Domain; it may be used for any purpose whatsoever  */
  9. /*    without restriction.                                                   */
  10. /*                                                                           */
  11. /*    This package is distributed in the hope that it will be useful,        */
  12. /*    but WITHOUT ANY WARRANTY; without even the implied warranty of         */
  13. /*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.                   */
  14. /*                                                                           */
  15. /*    Thomas R. Lawrence can be reached at tomlaw@world.std.com.             */
  16. /*                                                                           */
  17. /*****************************************************************************/
  18.  
  19. #include "MiscInfo.h"
  20. #include "Debug.h"
  21. #include "Audit.h"
  22. #include "Definitions.h"
  23.  
  24. #pragma options(pack_enums)
  25. #include <SANE.h>
  26. #pragma options(!pack_enums)
  27.  
  28. #include "FloatingPoint.h"
  29.  
  30.  
  31. #ifdef THINK_C
  32.     #if !__option(mc68881) && __option(native_fp)
  33.         /* native for no FPU = always 10-byte (no convertion necessary) */
  34.         #define x80tox96(X,Y) (*(Y) = *(X))
  35.         #define x96tox80(X,Y) (*(Y) = *(X))
  36.     #else
  37.         /* use normal definition */
  38.     #endif
  39. #endif
  40.  
  41.  
  42. long double                XGETPI(void)
  43.     {
  44.         extended            A;
  45.         long double        B;
  46.  
  47.         A = pi();
  48.         x80tox96(&A,&B);
  49.         return B;
  50.     }
  51.  
  52.  
  53. long double                XATAN(long double X)
  54.     {
  55.         extended            A;
  56.         long double        B;
  57.  
  58.         x96tox80(&X,&A);
  59.         A = atan(A);
  60.         x80tox96(&A,&B);
  61.         return B;
  62.     }
  63.  
  64.  
  65. long double                XCOS(long double X)
  66.     {
  67.         extended            A;
  68.         long double        B;
  69.  
  70.         x96tox80(&X,&A);
  71.         A = cos(A);
  72.         x80tox96(&A,&B);
  73.         return B;
  74.     }
  75.  
  76.  
  77. long double                XEXP(long double X)
  78.     {
  79.         extended            A;
  80.         long double        B;
  81.  
  82.         x96tox80(&X,&A);
  83.         A = exp(A);
  84.         x80tox96(&A,&B);
  85.         return B;
  86.     }
  87.  
  88.  
  89. long double                XFABS(long double X)
  90.     {
  91.         extended            A;
  92.         long double        B;
  93.  
  94.         x96tox80(&X,&A);
  95.         A = fabs(A);
  96.         x80tox96(&A,&B);
  97.         return B;
  98.     }
  99.  
  100.  
  101. long double                XLN(long double X)
  102.     {
  103.         extended            A;
  104.         long double        B;
  105.  
  106.         x96tox80(&X,&A);
  107.         A = log(A);
  108.         x80tox96(&A,&B);
  109.         return B;
  110.     }
  111.  
  112.  
  113. long double                XSIN(long double X)
  114.     {
  115.         extended            A;
  116.         long double        B;
  117.  
  118.         x96tox80(&X,&A);
  119.         A = sin(A);
  120.         x80tox96(&A,&B);
  121.         return B;
  122.     }
  123.  
  124.  
  125. long double                XSQRT(long double X)
  126.     {
  127.         extended            A;
  128.         long double        B;
  129.  
  130.         x96tox80(&X,&A);
  131.         A = sqrt(A);
  132.         x80tox96(&A,&B);
  133.         return B;
  134.     }
  135.  
  136.  
  137. long double                XTAN(long double X)
  138.     {
  139.         extended            A;
  140.         long double        B;
  141.  
  142.         x96tox80(&X,&A);
  143.         A = tan(A);
  144.         x80tox96(&A,&B);
  145.         return B;
  146.     }
  147.  
  148.  
  149. long double                XPOWER(long double X, long double Y)
  150.     {
  151.         extended            XX;
  152.         extended            YY;
  153.         extended            ZZ;
  154.         long double        Z;
  155.  
  156.         x96tox80(&X,&XX);
  157.         x96tox80(&Y,&YY);
  158.         ZZ = power(XX,YY);
  159.         x80tox96(&ZZ,&Z);
  160.         return Z;
  161.     }
  162.  
  163.  
  164. long double                XACOS(long double X)
  165.     {
  166.         return 2 * XATAN(XSQRT((1 - X) / (1 + X)));
  167.     }
  168.  
  169.  
  170. long double                XASIN(long double X)
  171.     {
  172.         long double        Y;
  173.  
  174.         Y = XFABS(X);
  175.         if (Y > 0.5)
  176.             {
  177.                 Y = 1 - Y;
  178.                 Y = 2 * Y - Y * Y;
  179.             }
  180.          else
  181.             {
  182.                 Y = 1 - Y * Y;
  183.             }
  184.         return XATAN(X / XSQRT(Y));
  185.     }
  186.